import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

@SuppressWarnings("all")

class Counter {
    private int count;
    synchronized public void increase() {
        this.count++;
    }
    public int getCount() {
        return this.count;
    }
}
@SuppressWarnings("all")
public class Main {

    private static final int CNT = 1_0000;
    private static final Counter counter = new Counter();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < CNT; i++) {
                counter.increase();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < CNT; i++) {
                counter.increase();
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println(counter.getCount());
    }



    //    给定一个很长的数组 (长度 1000w), 通过随机数的方式生成 1-100 之间的整数.
    //    实现代码, 能够创建两个线程, 对这个数组的所有元素求和.
    //    其中线程1 计算偶数下标元素的和, 线程2 计算奇数下标元素的和.
    //    最终再汇总两个和, 进行相加
    //    记录程序的执行时间.

    public static void main1(String[] args) throws InterruptedException, ExecutionException {
        // 记录开始执行的时间
        long startTime = System.currentTimeMillis();

        int[] arrays = new int[100_0000];
        // 1. 使用随机数初始化数组
        Random random = new Random();
        for (int i = 0; i < arrays.length; i++) {
            int tmp = random.nextInt(100) + 1;
            arrays[i] = tmp;
        }

        // 2. 创建两个线程执行相加操作
        // 2.1 返回偶数之和
        FutureTask<Integer> task1 = new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int tmp = 0;
                for (int i = 0; i < arrays.length; i += 2) {
                    tmp += arrays[i];
                }
                System.out.println("线程1" + tmp);
                return tmp;
            }
        });
        Thread t1 = new Thread(task1);
        t1.start();

        // 2.2 返回奇数之和
        FutureTask<Integer> task2 = new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int tmp = 0;
                for (int i = 1; i < arrays.length; i += 2) {
                    tmp += arrays[i];
                }
                System.out.println("线程1" + tmp);
                return tmp;
            }
        });
        Thread t2 = new Thread(task2);
        t2.start();

//        // 如果普通线程需要等待他们执行完，join一定要保留
//        t1.join();
//        t2.join();

        // get方法需要得到线程的返回值，当线程执行完才能有返回值，因此，如果使用的带
        // 返回值的线程创建方式，是不需要加 join 等待线程执行完的。
        int sum = task1.get() + task2.get();
        System.out.println("最终结果：" + sum);

        // 记录一下执行完成的时间
        long endTime = System.currentTimeMillis();

        // 使用结束时间 - 开始时间 = 执行时间
        System.out.println("最终执行时间：" + (endTime - startTime));
    }
}
